
Nanodegree key: nd101
Version: 7.0.0
Locale: en-us
This course trains the learner about foundational topics in the exciting field of deep learning, the technology behind state-of-the-art artificial intelligence.
Content
Part 01 (FreePreview): Deep Learning Free Preview
In this free preview of the Deep Learning Nanodegree program, you'll be introduced to the program, and get the opportunity to experiment with some existing, deep learning applications.
-
Module 01: Deep Learning Free Preview
-
Lesson 01: Welcome to Your Free Preview!
Get introduced to the program, discover the services we provide, and learn about the incredible projects you'll build.
-
Lesson 02: Applying Deep Learning
In this lesson, you'll experiment with a few examples of deep learning. This is meant to get you acquainted with a variety of applications, then later you'll learn the details of how they work!
-
Lesson 03: What's Next
To take your learning further, consider enrolling in the Deep Learning Nanodegree program.
-
Part 02 : Introduction to Deep Learning
Introduce yourself to deep learning by applying style transfer to your own images, and gaining experience using development tools such as Anaconda and Jupyter notebooks.
-
Module 01: Introduction to the Nanodegree
-
Lesson 01: Welcome to the Deep Learning Nanodegree Program
Welcome to the Deep Learning Nanodegree program! Learn about the program structure and resources!
-
Lesson 02: Nanodegree Career Services
The Careers team at Udacity is here to help you move forward in your career - whether it's finding a new job, exploring a new career path, or applying new skills to your current job.
-
Lesson 03: Knowledge, Community, and Careers
You are starting a challenging but rewarding journey! Take 5 minutes to read how to get help with projects and content.
-
Lesson 04: Get Help with Your Account
What to do if you have questions about your account or general questions about the program.
-
-
Module 02: Anaconda
-
Lesson 01: Anaconda
Anaconda is a package and environment manager built specifically for data. Learn how to use Anaconda to improve your data analysis workflow.
-
-
Module 03: Applying Deep Learning
-
Lesson 01: Applying Deep Learning
In this lesson, you'll experiment with a few examples of deep learning. This is meant to get you acquainted with a variety of applications, then later you'll learn the details of how they work!
-
-
Module 04: Jupyter Notebooks
-
Lesson 01: Jupyter Notebooks
Learn how to use Jupyter Notebooks to create documents combining code, text, images, and more.
- Concept 01: Instructor
- Concept 02: What are Jupyter notebooks?
- Concept 03: Installing Jupyter Notebook
- Concept 04: Launching the notebook server
- Concept 05: Notebook interface
- Concept 06: Code cells
- Concept 07: Markdown cells
- Concept 08: Keyboard shortcuts
- Concept 09: Magic keywords
- Concept 10: Converting notebooks
- Concept 11: Creating a slideshow
- Concept 12: Finishing up
-
-
Module 05: Matrix Math and NumPy Refresher
-
Lesson 01: Matrix Math and NumPy Refresher
In this lesson, you'll review the matrix math you'll need to understand to build your neural networks. You'll also explore NumPy, the library you'll use to efficiently deal with matrices in Python.
- Concept 01: Introduction
- Concept 02: Data Dimensions
- Concept 03: Data in NumPy
- Concept 04: Element-wise Matrix Operations
- Concept 05: Element-wise Operations in NumPy
- Concept 06: Matrix Multiplication: Part 1
- Concept 07: Matrix Multiplication: Part 2
- Concept 08: NumPy Matrix Multiplication
- Concept 09: Matrix Transposes
- Concept 10: Transposes in NumPy
- Concept 11: NumPy Quiz
-
Part 03 : Neural Networks
Learn neural network basics, and build your first network with Python and NumPy. Use the modern deep learning framework PyTorch to build multi-layer neural networks, and analyze real data.
-
Module 01: Introduction to Neural Networks
-
Lesson 01: Introduction to Neural Networks
In this lesson, Luis will teach you the foundations of deep learning and neural networks. You'll also implement gradient descent and backpropagation in python, right here in the classroom!
- Concept 01: Instructor
- Concept 02: Introduction
- Concept 03: Classification Problems 1
- Concept 04: Classification Problems 2
- Concept 05: Linear Boundaries
- Concept 06: Higher Dimensions
- Concept 07: Perceptrons
- Concept 08: Why "Neural Networks"?
- Concept 09: Perceptrons as Logical Operators
- Concept 10: Perceptron Trick
- Concept 11: Perceptron Algorithm
- Concept 12: Non-Linear Regions
- Concept 13: Error Functions
- Concept 14: Log-loss Error Function
- Concept 15: Discrete vs Continuous
- Concept 16: Softmax
- Concept 17: One-Hot Encoding
- Concept 18: Maximum Likelihood
- Concept 19: Maximizing Probabilities
- Concept 20: Cross-Entropy 1
- Concept 21: Cross-Entropy 2
- Concept 22: Multi-Class Cross Entropy
- Concept 23: Logistic Regression
- Concept 24: Gradient Descent
- Concept 25: Logistic Regression Algorithm
- Concept 26: Pre-Notebook: Gradient Descent
- Concept 27: Notebook: Gradient Descent
- Concept 28: Perceptron vs Gradient Descent
- Concept 29: Continuous Perceptrons
- Concept 30: Non-linear Data
- Concept 31: Non-Linear Models
- Concept 32: Neural Network Architecture
- Concept 33: Feedforward
- Concept 34: Backpropagation
- Concept 35: Pre-Notebook: Analyzing Student Data
- Concept 36: Notebook: Analyzing Student Data
- Concept 37: Outro
-
-
Module 02: Implementing Gradient Descent
-
Lesson 01: Implementing Gradient Descent
Mat will introduce you to a different error function and guide you through implementing gradient descent using NumPy matrix multiplication.
- Concept 01: Mean Squared Error Function
- Concept 02: Gradient Descent
- Concept 03: Gradient Descent: The Math
- Concept 04: Gradient Descent: The Code
- Concept 05: Implementing Gradient Descent
- Concept 06: Multilayer Perceptrons
- Concept 07: Backpropagation
- Concept 08: Implementing Backpropagation
- Concept 09: Further Reading
-
-
Module 03: Training Neural Networks
-
Lesson 01: Training Neural Networks
Now that you know what neural networks are, in this lesson you will learn several techniques to improve their training.
- Concept 01: Instructor
- Concept 02: Training Optimization
- Concept 03: Testing
- Concept 04: Overfitting and Underfitting
- Concept 05: Early Stopping
- Concept 06: Regularization
- Concept 07: Regularization 2
- Concept 08: Dropout
- Concept 09: Local Minima
- Concept 10: Random Restart
- Concept 11: Vanishing Gradient
- Concept 12: Other Activation Functions
- Concept 13: Batch vs Stochastic Gradient Descent
- Concept 14: Learning Rate Decay
- Concept 15: Momentum
- Concept 16: Error Functions Around the World
-
-
Module 04: GPU Workspaces Demo
-
Lesson 01: GPU Workspaces Demo
See a demonstration of GPU workspaces in the Udacity classroom.
-
-
Module 05: Sentiment Analysis
-
Lesson 01: Sentiment Analysis
In this lesson, Andrew Trask, the author of Grokking Deep Learning, will walk you through using neural networks for sentiment analysis.
- Concept 01: Introducing Andrew Trask
- Concept 02: Meet Andrew
- Concept 03: Materials
- Concept 04: The Notebooks
- Concept 05: Framing the Problem
- Concept 06: Mini Project 1
- Concept 07: Mini Project 1 Solution
- Concept 08: Transforming Text into Numbers
- Concept 09: Mini Project 2
- Concept 10: Mini Project 2 Solution
- Concept 11: Building a Neural Network
- Concept 12: Mini Project 3
- Concept 13: Mini Project 3 Solution
- Concept 14: Better Weight Initialization Strategy
- Concept 15: Understanding Neural Noise
- Concept 16: Mini Project 4
- Concept 17: Understanding Inefficiencies in our Network
- Concept 18: Mini Project 5
- Concept 19: Mini Project 5 Solution
- Concept 20: Further Noise Reduction
- Concept 21: Mini Project 6
- Concept 22: Mini Project 6 Solution
- Concept 23: Analysis: What's Going on in the Weights?
- Concept 24: Conclusion
-
-
Module 06: Project: Predicting Bike-Sharing Patterns
-
Lesson 01: Project: Predicting Bike-Sharing Patterns
In this project, you'll build and train your own Neural Network from scratch to predict the number of bikeshare users on a given day. Good luck!
-
-
Module 07: Deep Learning with PyTorch
-
Lesson 01: Deep Learning with PyTorch
Learn how to use PyTorch for building deep learning models
- Concept 01: Welcome!
- Concept 02: Pre-Notebook
- Concept 03: Notebook Workspace
- Concept 04: Single layer neural networks
- Concept 05: Single layer neural networks solution
- Concept 06: Networks Using Matrix Multiplication
- Concept 07: Multilayer Networks Solution
- Concept 08: Neural Networks in PyTorch
- Concept 09: Neural Networks Solution
- Concept 10: Implementing Softmax Solution
- Concept 11: Network Architectures in PyTorch
- Concept 12: Network Architectures Solution
- Concept 13: Training a Network Solution
- Concept 14: Classifying Fashion-MNIST
- Concept 15: Fashion-MNIST Solution
- Concept 16: Inference and Validation
- Concept 17: Validation Solution
- Concept 18: Dropout Solution
- Concept 19: Saving and Loading Models
- Concept 20: Loading Image Data
- Concept 21: Loading Image Data Solution
- Concept 22: Pre-Notebook with GPU
- Concept 23: Notebook Workspace w/ GPU
- Concept 24: Transfer Learning II
- Concept 25: Transfer Learning Solution
- Concept 26: Tips, Tricks, and Other Notes
-
Part 04 : Convolutional Neural Networks
Learn how to build convolutional networks and use them to classify images (faces, melanomas, etc.) based on patterns and objects that appear in them. Use these networks to learn data compression and image de-noising.
-
Module 01: Convolutional Neural Networks
-
Lesson 01: Convolutional Neural Networks
Convolutional Neural Networks allow for spatial pattern recognition. Alexis and Cezanne go over how they help us dramatically improve performance in image classification.
- Concept 01: Introducing Alexis
- Concept 02: Applications of CNNs
- Concept 03: Lesson Outline
- Concept 04: MNIST Dataset
- Concept 05: How Computers Interpret Images
- Concept 06: MLP Structure & Class Scores
- Concept 07: Do Your Research
- Concept 08: Loss & Optimization
- Concept 09: Defining a Network in PyTorch
- Concept 10: Training the Network
- Concept 11: Pre-Notebook: MLP Classification, Exercise
- Concept 12: Notebook: MLP Classification, MNIST
- Concept 13: One Solution
- Concept 14: Model Validation
- Concept 15: Validation Loss
- Concept 16: Image Classification Steps
- Concept 17: MLPs vs CNNs
- Concept 18: Local Connectivity
- Concept 19: Filters and the Convolutional Layer
- Concept 20: Filters & Edges
- Concept 21: Frequency in Images
- Concept 22: High-pass Filters
- Concept 23: Quiz: Kernels
- Concept 24: OpenCV & Creating Custom Filters
- Concept 25: Notebook: Finding Edges
- Concept 26: Convolutional Layer
- Concept 27: Convolutional Layers (Part 2)
- Concept 28: Stride and Padding
- Concept 29: Pooling Layers
- Concept 30: Notebook: Layer Visualization
- Concept 31: Capsule Networks
- Concept 32: Increasing Depth
- Concept 33: CNNs for Image Classification
- Concept 34: Convolutional Layers in PyTorch
- Concept 35: Feature Vector
- Concept 36: Pre-Notebook: CNN Classification
- Concept 37: Notebook: CNNs for CIFAR Image Classification
- Concept 38: CIFAR Classification Example
- Concept 39: CNNs in PyTorch
- Concept 40: Image Augmentation
- Concept 41: Augmentation Using Transformations
- Concept 42: Groundbreaking CNN Architectures
- Concept 43: Visualizing CNNs (Part 1)
- Concept 44: Visualizing CNNs (Part 2)
- Concept 45: Summary of CNNs
- Concept 46: Introduction to GPU Workspaces
- Concept 47: Workspace Playground
- Concept 48: GPU Workspace Playground
-
Lesson 02: GPU Workspaces Demo
See a demonstration of GPU workspaces in the Udacity classroom.
-
Lesson 03: Cloud Computing
Take advantage of Amazon's GPUs to train your neural network faster. In this lesson, you'll setup an instance on AWS and train a neural network on a GPU.
-
Lesson 04: Transfer Learning
Learn how to apply a pre-trained network to a new problem with transfer learning.
-
Lesson 05: Weight Initialization
In this lesson, you'll learn how to find good initial weights for a neural network. Having good initial weights can place the neural network closer to the optimal solution.
- Concept 01: Weight Initialization
- Concept 02: Constant Weights
- Concept 03: Random Uniform
- Concept 04: General Rule
- Concept 05: Normal Distribution
- Concept 06: Pre-Notebook: Weight Initialization, Normal Distribution
- Concept 07: Notebook: Normal & No Initialization
- Concept 08: Solution and Default Initialization
- Concept 09: Additional Material
-
Lesson 06: Autoencoders
Autoencoders are neural networks used for data compression, image de-noising, and dimensionality reduction. Here, you'll build autoencoders using PyTorch.
- Concept 01: Autoencoders
- Concept 02: A Linear Autoencoder
- Concept 03: Pre-Notebook: Linear Autoencoder
- Concept 04: Notebook: Linear Autoencoder
- Concept 05: Defining & Training an Autoencoder
- Concept 06: A Simple Solution
- Concept 07: Learnable Upsampling
- Concept 08: Transpose Convolutions
- Concept 09: Convolutional Autoencoder
- Concept 10: Pre-Notebook: Convolutional Autoencoder
- Concept 11: Notebook: Convolutional Autoencoder
- Concept 12: Convolutional Solution
- Concept 13: Upsampling & Denoising
- Concept 14: De-noising
- Concept 15: Pre-Notebook: De-noising Autoencoder
- Concept 16: Notebook: De-noising Autoencoder
-
-
Module 02: Style Transfer
-
Lesson 01: Style Transfer
Learn how to use a pre-trained network to extract content and style features from an image. Implement style transfer with your own images!
- Concept 01: Style Transfer
- Concept 02: Separating Style & Content
- Concept 03: VGG19 & Content Loss
- Concept 04: Gram Matrix
- Concept 05: Style Loss
- Concept 06: Loss Weights
- Concept 07: VGG Features
- Concept 08: Pre-Notebook: Style Transfer
- Concept 09: Notebook: Style Transfer
- Concept 10: Features & Gram Matrix
- Concept 11: Gram Matrix Solution
- Concept 12: Defining the Loss
- Concept 13: Total Loss & Complete Solution
-
-
Module 03: Project: Dog-Breed Classifier
-
Lesson 01: Project: Dog-Breed Classifier
In this project, you will learn how to build a pipeline to process real-world, user-supplied images. Given an image of a dog, your algorithm will identify an estimate of the canine’s breed.
-
-
Module 04: Deep Learning for Cancer Detection
-
Lesson 01: Deep Learning for Cancer Detection
In this lesson, Sebastian Thrun teaches us about his groundbreaking work detecting skin cancer with convolutional neural networks.
- Concept 01: Intro
- Concept 02: Skin Cancer
- Concept 03: Survival Probability of Skin Cancer
- Concept 04: Medical Classification
- Concept 05: The data
- Concept 06: Image Challenges
- Concept 07: Quiz: Data Challenges
- Concept 08: Solution: Data Challenges
- Concept 09: Training the Neural Network
- Concept 10: Quiz: Random vs Pre-initialized Weights
- Concept 11: Solution: Random vs Pre-initialized Weight
- Concept 12: Validating the Training
- Concept 13: Quiz: Sensitivity and Specificity
- Concept 14: Solution: Sensitivity and Specificity
- Concept 15: More on Sensitivity and Specificity
- Concept 16: Quiz: Diagnosing Cancer
- Concept 17: Solution: Diagnosing Cancer
- Concept 18: Refresh on ROC Curves
- Concept 19: Quiz: ROC Curve
- Concept 20: Solution: ROC Curve
- Concept 21: Comparing our Results with Doctors
- Concept 22: Visualization
- Concept 23: What is the network looking at?
- Concept 24: Refresh on Confusion Matrices
- Concept 25: Confusion Matrix
- Concept 26: Conclusion
- Concept 27: Useful Resources
- Concept 28: Mini Project Introduction
- Concept 29: Mini Project: Dermatologist AI
-
-
Module 05: Jobs in Deep Learning
-
Lesson 01: Jobs in Deep Learning
To kick off your industry research, learn about real world applications of Deep Learning and common questions about jobs in this field.
-
Lesson 02: Optimize Your GitHub Profile
Other professionals are collaborating on GitHub and growing their network. Submit your profile to ensure your profile is on par with leaders in your field.
- Concept 01: Prove Your Skills With GitHub
- Concept 02: Introduction
- Concept 03: GitHub profile important items
- Concept 04: Good GitHub repository
- Concept 05: Interview with Art - Part 1
- Concept 06: Identify fixes for example “bad” profile
- Concept 07: Quick Fixes #1
- Concept 08: Quick Fixes #2
- Concept 09: Writing READMEs with Walter
- Concept 10: Interview with Art - Part 2
- Concept 11: Commit messages best practices
- Concept 12: Reflect on your commit messages
- Concept 13: Participating in open source projects
- Concept 14: Interview with Art - Part 3
- Concept 15: Participating in open source projects 2
- Concept 16: Starring interesting repositories
- Concept 17: Next Steps
-
Part 05 : Recurrent Neural Networks
Build your own recurrent networks and long short-term memory networks with PyTorch; perform sentiment analysis and use recurrent networks to generate new text from TV scripts.
-
Module 01: Recurrent Neural Networks
-
Lesson 01: Recurrent Neural Networks
Explore how memory can be incorporated into a deep learning model using recurrent neural networks (RNNs). Learn how RNNs can learn from and generate ordered sequences of data.
- Concept 01: RNN Examples
- Concept 02: RNN Introduction
- Concept 03: RNN History
- Concept 04: RNN Applications
- Concept 05: Feedforward Neural Network-Reminder
- Concept 06: The Feedforward Process
- Concept 07: Feedforward Quiz
- Concept 08: Backpropagation- Theory
- Concept 09: Backpropagation - Example (part a)
- Concept 10: Backpropagation- Example (part b)
- Concept 11: Backpropagation Quiz
- Concept 12: RNN (part a)
- Concept 13: RNN (part b)
- Concept 14: RNN- Unfolded Model
- Concept 15: Unfolded Model Quiz
- Concept 16: RNN- Example
- Concept 17: Backpropagation Through Time (part a)
- Concept 18: Backpropagation Through Time (part b)
- Concept 19: Backpropagation Through Time (part c)
- Concept 20: BPTT Quiz 1
- Concept 21: BPTT Quiz 2
- Concept 22: BPTT Quiz 3
- Concept 23: Some more math
- Concept 24: RNN Summary
- Concept 25: From RNN to LSTM
- Concept 26: Wrap Up
-
Lesson 02: Long Short-Term Memory Networks (LSTMs)
Luis explains Long Short-Term Memory Networks (LSTM), and similar architectures which have the benefits of preserving long term memory.
- Concept 01: Intro to LSTM
- Concept 02: RNN vs LSTM
- Concept 03: Basics of LSTM
- Concept 04: Architecture of LSTM
- Concept 05: The Learn Gate
- Concept 06: The Forget Gate
- Concept 07: The Remember Gate
- Concept 08: The Use Gate
- Concept 09: Putting it All Together
- Concept 10: Quiz
- Concept 11: Other architectures
-
Lesson 03: Implementation of RNN & LSTM
Learn how to represent memory in code. Then define and train RNNs in PyTorch and apply them to tasks that involve sequential data.
- Concept 01: Implementing RNNs
- Concept 02: Time-Series Prediction
- Concept 03: Training & Memory
- Concept 04: Character-wise RNNs
- Concept 05: Sequence Batching
- Concept 06: Pre-Notebook: Character-Level RNN
- Concept 07: Notebook: Character-Level RNN
- Concept 08: Implementing a Char-RNN
- Concept 09: Batching Data, Solution
- Concept 10: Defining the Model
- Concept 11: Char-RNN, Solution
- Concept 12: Making Predictions
-
Lesson 04: Hyperparameters
Learn about a number of different hyperparameters that are used in defining and training deep learning models. We'll discuss starting values and intuitions for tuning each hyperparameter.
- Concept 01: Introducing Jay
- Concept 02: Introduction
- Concept 03: Learning Rate
- Concept 04: Learning Rate
- Concept 05: Minibatch Size
- Concept 06: Number of Training Iterations / Epochs
- Concept 07: Number of Hidden Units / Layers
- Concept 08: RNN Hyperparameters
- Concept 09: RNN Hyperparameters
- Concept 10: Sources & References
-
Lesson 05: Embeddings & Word2Vec
In this lesson, you'll learn about embeddings in neural networks by implementing the Word2Vec model.
- Concept 01: Word Embeddings
- Concept 02: Embedding Weight Matrix/Lookup Table
- Concept 03: Word2Vec Notebook
- Concept 04: Pre-Notebook: Word2Vec, SkipGram
- Concept 05: Notebook: Word2Vec, SkipGram
- Concept 06: Data & Subsampling
- Concept 07: Subsampling Solution
- Concept 08: Context Word Targets
- Concept 09: Batching Data, Solution
- Concept 10: Word2Vec Model
- Concept 11: Model & Validations
- Concept 12: Negative Sampling
- Concept 13: Pre-Notebook: Negative Sampling
- Concept 14: Notebook: Negative Sampling
- Concept 15: SkipGramNeg, Model Definition
- Concept 16: Complete Model & Custom Loss
-
Lesson 06: Sentiment Prediction RNN
Implement a sentiment prediction RNN for predicting whether a movie review is positive or negative!
- Concept 01: Sentiment RNN, Introduction
- Concept 02: Pre-Notebook: Sentiment RNN
- Concept 03: Notebook: Sentiment RNN
- Concept 04: Data Pre-Processing
- Concept 05: Encoding Words, Solution
- Concept 06: Getting Rid of Zero-Length
- Concept 07: Cleaning & Padding Data
- Concept 08: Padded Features, Solution
- Concept 09: TensorDataset & Batching Data
- Concept 10: Defining the Model
- Concept 11: Complete Sentiment RNN
- Concept 12: Training the Model
- Concept 13: Testing
- Concept 14: Inference, Solution
-
-
Module 02: Project: Generate TV Scripts
-
Lesson 01: Project: Generate TV Scripts
Generate a TV script by defining and training a recurrent neural network.
-
-
Module 03: Attention
-
Lesson 01: Attention
Attention is one of the most important recent innovations in deep learning. In this section, you'll learn how attention models work and go over a basic code implementation.
- Concept 01: Introduction to Attention
- Concept 02: Encoders and Decoders
- Concept 03: Sequence to Sequence Recap
- Concept 04: Encoding -- Attention Overview
- Concept 05: Decoding -- Attention Overview
- Concept 06: Attention Overview
- Concept 07: Attention Encoder
- Concept 08: Attention Decoder
- Concept 09: Attention Encoder & Decoder
- Concept 10: Bahdanau and Luong Attention
- Concept 11: Multiplicative Attention
- Concept 12: Additive Attention
- Concept 13: Additive and Multiplicative Attention
- Concept 14: Computer Vision Applications
- Concept 15: Other Attention Methods
- Concept 16: The Transformer and Self-Attention
- Concept 17: Notebook: Attention Basics
- Concept 18: [SOLUTION]: Attention Basics
- Concept 19: Outro
-
Part 06 : Generative Adversarial Networks
Learn to understand and implement a Deep Convolutional GAN (generative adversarial network) to generate realistic images, with Ian Goodfellow, the inventor of GANs, and Jun-Yan Zhu, the creator of CycleGANs.
-
Module 01: Generative Adversarial Networks
-
Lesson 01: Generative Adversarial Networks
Ian Goodfellow, the inventor of GANs, introduces you to these exciting models. You'll also implement your own GAN on the MNIST dataset.
- Concept 01: Introducing Ian GoodFellow
- Concept 02: Applications of GANs
- Concept 03: How GANs work
- Concept 04: Games and Equilibria
- Concept 05: Tips for Training GANs
- Concept 06: Generating Fake Images
- Concept 07: MNIST GAN
- Concept 08: GAN Notebook & Data
- Concept 09: Pre-Notebook: MNIST GAN
- Concept 10: Notebook: MNIST GAN
- Concept 11: The Complete Model
- Concept 12: Generator & Discriminator
- Concept 13: Hyperparameters
- Concept 14: Fake and Real Losses
- Concept 15: Optimization Strategy, Solution
- Concept 16: Training Two Networks
- Concept 17: Training Solution
-
Lesson 02: Deep Convolutional GANs
In this lesson you'll implement a Deep Convolution GAN to generate complex color images of house numbers.
- Concept 01: Deep Convolutional GANs
- Concept 02: DCGAN, Discriminator
- Concept 03: DCGAN Generator
- Concept 04: What is Batch Normalization?
- Concept 05: Pre-Notebook: Batch Norm
- Concept 06: Notebook: Batch Norm
- Concept 07: Benefits of Batch Normalization
- Concept 08: DCGAN Notebook & Data
- Concept 09: Pre-Notebook: DCGAN, SVHN
- Concept 10: Notebook: DCGAN, SVHN
- Concept 11: Scaling, Solution
- Concept 12: Discriminator
- Concept 13: Discriminator, Solution
- Concept 14: Generator
- Concept 15: Generator, Solution
- Concept 16: Optimization Strategy
- Concept 17: Optimization Solution & Samples
- Concept 18: Other Applications of GANs
-
-
Module 02: Pix2Pix & CycleGAN
-
Lesson 01: Pix2Pix & CycleGAN
Jun-Yan Zhu, on of the creators of the CycleGAN, will lead you through Pix2Pix and CycleGAN formulations that learn to do image-to-image translation tasks!
- Concept 01: Introducing Jun-Yan Zhu
- Concept 02: Image to Image Translation
- Concept 03: Designing Loss Functions
- Concept 04: GANs, a Recap
- Concept 05: Pix2Pix Generator
- Concept 06: Pix2Pix Discriminator
- Concept 07: CycleGANs & Unpaired Data
- Concept 08: Cycle Consistency Loss
- Concept 09: Why Does This Work?
- Concept 10: Beyond CycleGANs
-
Lesson 02: Implementing a CycleGAN
Cezanne will show you how to implement a CycleGAN in PyTorch and translate images from the summer to winter domains.
- Concept 01: CycleGAN Notebook & Data
- Concept 02: Pre-Notebook: CycleGAN
- Concept 03: Notebook: CycleGAN
- Concept 04: DC Discriminator
- Concept 05: DC Discriminator, Solution
- Concept 06: Generator & Residual Blocks
- Concept 07: CycleGAN Generator
- Concept 08: Blocks & Generator, Solution
- Concept 09: Adversarial & Cycle Consistency Losses
- Concept 10: Loss & Optimization, Solution
- Concept 11: Training Exercise
- Concept 12: Training Solution & Generated Samples
-
-
Module 03: Project: Generate Faces
-
Lesson 01: Project: Generate Faces
Define two adversarial networks, a generator and discriminator, and train them until you can generate realistic faces.
-
-
Module 04: Improve Your Online Presence Using LinkedIn
-
Lesson 01: Take 30 Min to Improve your LinkedIn
Find your next job or connect with industry peers on LinkedIn. Ensure your profile attracts relevant leads that will grow your professional network.
- Concept 01: Get Opportunities with LinkedIn
- Concept 02: Use Your Story to Stand Out
- Concept 03: Why Use an Elevator Pitch
- Concept 04: Create Your Elevator Pitch
- Concept 05: Use Your Elevator Pitch on LinkedIn
- Concept 06: Create Your Profile With SEO In Mind
- Concept 07: Profile Essentials
- Concept 08: Work Experiences & Accomplishments
- Concept 09: Build and Strengthen Your Network
- Concept 10: Reaching Out on LinkedIn
- Concept 11: Boost Your Visibility
- Concept 12: Up Next
-
Part 07 : Deploying a Model
Train and deploy your own sentiment analysis model using Amazon's SageMaker. Deployment gives you the ability to use a trained model to analyze new, user input. Build a model, deploy it, and create a gateway for accessing it from a website.
-
Module 01: Deployment
-
Lesson 01: Introduction to Deployment
This lesson will familiarizing the student with cloud and deployment terminology along with demonstrating how deployment fits within the machine learning workflow.
- Concept 01: Welcome!
- Concept 02: What's Ahead?
- Concept 03: Problem Introduction
- Concept 04: Machine Learning Workflow
- Concept 05: Machine Learning Workflow
- Concept 06: What is Cloud Computing & Why Would We Use It?
- Concept 07: Why Cloud Computing?
- Concept 08: Machine Learning Applications
- Concept 09: Machine Learning Applications
- Concept 10: Paths to Deployment
- Concept 11: Paths to Deployment
- Concept 12: Production Environments
- Concept 13: Production Environments
- Concept 14: Endpoints & REST APIs
- Concept 15: Endpoints & REST APIs
- Concept 16: Containers
- Concept 17: Containers
- Concept 18: Containers - Straight From the Experts
- Concept 19: Characteristics of Modeling & Deployment
- Concept 20: Characteristics of Modeling & Deployment
- Concept 21: Comparing Cloud Providers
- Concept 22: Comparing Cloud Providers
- Concept 23: Closing Statements
- Concept 24: Summary
- Concept 25: [Optional] Cloud Computing Defined
- Concept 26: [Optional] Cloud Computing Explained
-
Lesson 02: Building a Model using SageMaker
Learn how to use Amazon’s SageMaker service to predict Boston housing prices using SageMaker’s built-in XGBoost algorithm.
- Concept 01: Introduction to Amazon SageMaker
- Concept 02: AWS Setup Instructions for Regular account
- Concept 03: AWS SageMaker
- Concept 04: SageMaker Instance Utilization Limits
- Concept 05: Setting up a Notebook Instance
- Concept 06: Cloning the Deployment Notebooks
- Concept 07: Is Everything Set Up?
- Concept 08: Boston Housing Example - Getting the Data Ready
- Concept 09: Boston Housing Example - Training the Model
- Concept 10: Boston Housing Example - Testing the Model
- Concept 11: Mini-Project: Building Your First Model
- Concept 12: Mini-Project: Solution
- Concept 13: Boston Housing In-Depth - Data Preparation
- Concept 14: Boston Housing In-Depth - Creating a Training Job
- Concept 15: Boston Housing In-Depth - Building a Model
- Concept 16: Boston Housing In-Depth - Creating a Batch Transform Job
- Concept 17: Summary
-
Lesson 03: Deploying and Using a Model
In this lesson students will learn how to deploy a model using SageMaker and how to make use of their deployed model with a simple web application.
- Concept 01: Deploying a Model in SageMaker
- Concept 02: Boston Housing Example - Deploying the Model
- Concept 03: Boston Housing In-Depth - Deploying the Model
- Concept 04: Deploying and Using a Sentiment Analysis Model
- Concept 05: Text Processing, Bag of Words
- Concept 06: Building and Deploying the Model
- Concept 07: How to Use a Deployed Model
- Concept 08: Creating and Using an Endpoint
- Concept 09: Building a Lambda Function
- Concept 10: Building an API
- Concept 11: Using the Final Web Application
- Concept 12: Summary
-
Lesson 04: Hyperparameter Tuning
In this lesson students will see how to use SageMaker’s automatic hyperparameter tuning tools on the Boston housing prices model from lesson 2 and with a sentiment analysis model.
- Concept 01: Hyperparameter Tuning
- Concept 02: Introduction to Hyperparameter Tuning
- Concept 03: Boston Housing Example - Tuning the Model
- Concept 04: Mini-Project: Tuning the Sentiment Analysis Model
- Concept 05: Mini-Project: Solution - Tuning the Model
- Concept 06: Mini-Project: Solution - Fixing the Error and Testing
- Concept 07: Boston Housing In-Depth - Creating a Tuning Job
- Concept 08: Boston Housing In-Depth - Monitoring the Tuning Job
- Concept 09: Boston Housing In-Depth - Building and Testing the Model
- Concept 10: Summary
-
Lesson 05: Updating a Model
In this lesson students will learn how to update their model to account for changes in the underlying data used to train their model.
- Concept 01: Updating a Model
- Concept 02: Building a Sentiment Analysis Model (XGBoost)
- Concept 03: Building a Sentiment Analysis Model (Linear Learner)
- Concept 04: Combining the Models
- Concept 05: Mini-Project: Updating a Sentiment Analysis Model
- Concept 06: Loading and Testing the New Data
- Concept 07: Exploring the New Data
- Concept 08: Building a New Model
- Concept 09: SageMaker Retrospective
- Concept 10: Cleaning Up Your AWS Account
- Concept 11: SageMaker Tips and Tricks
-
-
Module 02: Project: Deploying a Sentiment Analysis Model
-
Lesson 01: Project: Deploying a Sentiment Analysis Model
In this project, you will build and deploy a neural network which predicts the sentiment of a user-provided movie review. In addition, you will create a simple web app that uses your deployed model.
-
Part 08 (Elective): Additional Lessons
Lessons that provide some additional examples on regression tasks and accuracy metrics as well as on the basic functions that run deep learning frameworks.
-
Module 01: Regression, Eval
-
Lesson 01: Evaluation Metrics
In this section, you will learn some of the most common metrics used to evaluate deep learning models.
-
Lesson 02: Regression
Luis gives you a foundation on linear regression, and some non-linear extensions, including the use of neural networks.
- Concept 01: Intro
- Concept 02: Quiz: Housing Prices
- Concept 03: Solution: Housing Prices
- Concept 04: Fitting a Line Through Data
- Concept 05: Moving a Line
- Concept 06: Absolute Trick
- Concept 07: Square Trick
- Concept 08: Gradient Descent
- Concept 09: Mean Absolute Error
- Concept 10: Mean Squared Error
- Concept 11: Minimizing Error Functions
- Concept 12: Mean vs Total Error
- Concept 13: Mini-batch Gradient Descent
- Concept 14: Absolute Error vs Squared Error
- Concept 15: Linear Regression in scikit-learn
- Concept 16: Higher Dimensions
- Concept 17: Multiple Linear Regression
- Concept 18: Closed Form Solution
- Concept 19: (Optional) Closed form Solution Math
- Concept 20: Linear Regression Warnings
- Concept 21: Polynomial Regression
- Concept 22: Regularization
- Concept 23: Neural Network Regression
- Concept 24: Neural Networks Playground
- Concept 25: Outro
-
-
Module 02: Miniflow
-
Lesson 01: MiniFlow
In this lesson, you'll build your own small version of TensorFlow, called MiniFlow. By building this, you'll gain an understanding of how TensorFlow works under the hood, and gain more insights into important concepts like backpropagation.
- Concept 01: Welcome to MiniFlow
- Concept 02: Graphs
- Concept 03: MiniFlow Architecture
- Concept 04: Forward Propagation
- Concept 05: Forward Propagation Solution
- Concept 06: Learning and Loss
- Concept 07: Linear Transform
- Concept 08: Sigmoid Function
- Concept 09: Cost
- Concept 10: Cost Solution
- Concept 11: Gradient Descent
- Concept 12: Backpropagation
- Concept 13: Stochastic Gradient Descent
- Concept 14: SGD Solution
- Concept 15: Outro
-
Part 09 (Elective): TensorFlow, Keras Frameworks
Optional: Learn how to approach deep learning and data-driven tasks using TensorFlow and Keras frameworks.
-
Module 01: Keras
-
Lesson 01: Introduction to Keras
In this section you'll define a neural network with Keras, and apply the framework to analyze movie reviews.
-
Lesson 02: Keras CNNs
Learn to define and train convolutional neural networks in Keras, as well as implement data augmentation and transfer learning.
- Concept 01: Convolutional Layers in Keras
- Concept 02: Quiz: Dimensionality
- Concept 03: CNNs in Keras: Practical Example
- Concept 04: Mini Project: CNNs in Keras
- Concept 05: Image Augmentation in Keras
- Concept 06: Mini Project: Image Augmentation in Keras
- Concept 07: Transfer Learning
- Concept 08: Transfer Learning in Keras
-
-
Module 02: TensorFlow
-
Lesson 01: Introduction to TensorFlow
In this section you'll get an introduction to TensorFlow, Google's deep learning framework, and you'll be able to apply it on an image dataset.
- Concept 01: Intro
- Concept 02: Installing TensorFlow
- Concept 03: Hello, Tensor World!
- Concept 04: Quiz: TensorFlow Input
- Concept 05: Quiz: TensorFlow Math
- Concept 06: Quiz: TensorFlow Linear Function
- Concept 07: Quiz: TensorFlow Softmax
- Concept 08: Quiz: TensorFlow Cross Entropy
- Concept 09: Quiz: Mini-batch
- Concept 10: Epochs
- Concept 11: Pre-Lab: NotMNIST in TensorFlow
- Concept 12: Lab: NotMNIST in TensorFlow
- Concept 13: Two-layer Neural Network
- Concept 14: Quiz: TensorFlow ReLUs
- Concept 15: Deep Neural Network in TensorFlow
- Concept 16: Save and Restore TensorFlow Models
- Concept 17: Finetuning
- Concept 18: Quiz: TensorFlow Dropout
- Concept 19: Outro
-